package com.bii.gelapp;

import java.util.ArrayList;
import java.util.Collections;

import org.opencv.android.Utils;
import org.opencv.core.Core;
import org.opencv.core.CvType;
import org.opencv.core.Mat;
import org.opencv.core.Point;
import org.opencv.core.Scalar;

import android.content.Context;
import android.graphics.Bitmap;
import android.graphics.Canvas;
import android.graphics.Matrix;
import android.graphics.PointF;
import android.graphics.drawable.BitmapDrawable;
import android.graphics.drawable.Drawable;
import android.os.Bundle;
import android.os.Parcelable;
import android.util.AttributeSet;
import android.util.Log;
import android.view.GestureDetector;
import android.view.MotionEvent;
import android.view.ScaleGestureDetector;
import android.view.View;
import android.widget.ImageView;

public class TouchImageView extends ImageView {
	Matrix matrix;

	// We can be in one of these 3 states
	static final int NONE = 0;
	static final int DRAG = 1;
	static final int ZOOM = 2;
	static final int CLICK = 3;
	int mode = NONE;
	// modes
	boolean editmode = false;
	boolean erasemode = false;
	boolean markermode = false;

	// Remember some things for zooming
	PointF last = new PointF();
	PointF start = new PointF();
	float minScale = 1f;
	float maxScale = 8f;
	float[] m;

	int viewWidth, viewHeight;
	float saveScale = 1f;
	protected float origWidth, origHeight;
	int oldMeasuredWidth, oldMeasuredHeight;

	public static Bitmap originalBmp;
	public static Bitmap activeBmp;
	Canvas canvas = null;

	ScaleGestureDetector mScaleDetector;

	GestureDetector gestureDetector;

	Context context;

	Bitmap bmap;
	//for current rectangle drawing
	Bitmap rectanglebmap;
	Mat drawmat;
	ArrayList<ConnectedComponent> componentlist = new ArrayList<ConnectedComponent>();
	ArrayList<ConnectedComponent> markerlist = new ArrayList<ConnectedComponent>();

	ArrayList<ConnectedComponent> templist = new ArrayList<ConnectedComponent>();
	ArrayList<ConnectedComponent> rectanglelist = new ArrayList<ConnectedComponent>();
	ArrayList<ConnectedComponent> addedmarkerlist = new ArrayList<ConnectedComponent>();

	// for connected component cc
	float rtop = 0;
	float rleft = 0;
	float rright = 0;
	float rbottom = 0;
	// for connected component dc
	float dtop = 0;
	float dleft = 0;
	float dright = 0;
	float dbottom = 0;

	// for image bounds
	float imagetop = 0;
	float imagebottom = 0;
	float imageleft = 0;
	float imageright = 0;

	float imagewidth;
	float imageheight;

	// set maximum zoom for matrix
	public void setMaxZoom(float x) {
		maxScale = x;
	}

	// used especially for setting the mode to edit
	public void setEditMode(boolean edit) {
		editmode = edit;
	}

	public void setEraseMode(boolean erase) {
		erasemode = erase;
	}

	public void setMarkersmode(boolean markers) {
		markermode = markers;
	}

	// used to remove the previously added circle
	public void undoTemp() {
		if (templist.size() > 0) {
			int templeft = templist.get(templist.size() - 1).left;
			int tempright = templist.get(templist.size() - 1).right;
			int temptop = templist.get(templist.size() - 1).top;
			int tempbottom = templist.get(templist.size() - 1).bottom;

			for (int i = rectanglelist.size() - 1; i > -1; i--) {
				if (rectanglelist.get(i).left == templeft
						&& rectanglelist.get(i).right == tempright
						&& rectanglelist.get(i).top == temptop
						&& rectanglelist.get(i).bottom == tempbottom) {
					rectanglelist.remove(i);
				}
			}
			for (int i = addedmarkerlist.size() - 1; i > -1; i--) {
				if (addedmarkerlist.get(i).left == templeft
						&& addedmarkerlist.get(i).right == tempright
						&& addedmarkerlist.get(i).top == temptop
						&& addedmarkerlist.get(i).bottom == tempbottom) {
					addedmarkerlist.remove(i);
				}
			}
			templist.remove(templist.size() - 1);
			drawRectangles();
		}
	}

	// constructor
	public TouchImageView(Context context, Bitmap bmp, Bitmap active) {
		super(context);
		// passing in image to be edited
		originalBmp = bmp;
		activeBmp = active;
		sharedConstructing(context);
	}

	// constructor 2
	public TouchImageView(Context context, AttributeSet attrs, Bitmap bmp,
			Bitmap active) {
		super(context, attrs);
		// passing in image to be edited
		originalBmp = bmp;
		activeBmp = active;
		sharedConstructing(context);
	}

	public TouchImageView(Context context, AttributeSet attrs) {
		super(context, attrs);
		sharedConstructing(context);
	}

	private void sharedConstructing(Context context) {
		// preparation for all the image loading and stuffs
		super.setClickable(true);
		this.context = context;

		/*
		 * if (circlelist.size() > 0) { drawCircles(); }
		 */

		bmap = originalBmp;
		drawmat = new Mat(bmap.getHeight(), bmap.getWidth(), CvType.CV_8U);
		// get all component list from fullactivity
		componentlist = FullscreenActivity.getComponentlist();
		if (componentlist.size() != 0) {
			for (int i = 0; i < componentlist.size(); i++) {
				rectanglelist.add(componentlist.get(i));

			}
		}
		if (rectanglelist.size() > 0) {
			drawRectangles();
		}
		// get all markers from fullactivity
		markerlist = FullscreenActivity.getMarkerlist();
		if (markerlist.size() != 0) {
			for (int i = 0; i < markerlist.size(); i++) {
				addedmarkerlist.add(markerlist.get(i));
			}
		}
		if (addedmarkerlist.size() > 0) {
			// drawMarkers();
			drawRectangles();
		}

		mScaleDetector = new ScaleGestureDetector(context, new ScaleListener());
		matrix = new Matrix();
		m = new float[9];
		setImageMatrix(matrix);
		// allow scaling of image by matrix
		setScaleType(ScaleType.MATRIX);

		// used for drawing circles

		setOnTouchListener(new OnTouchListener() {

			@Override
			public boolean onTouch(View v, MotionEvent event) {
				mScaleDetector.onTouchEvent(event);
				PointF curr = new PointF(event.getX(), event.getY());
				long starttime = 0;
				long endtime = 0;

				ConnectedComponent cc = new ConnectedComponent();
				// use to show the current rectangle drawn
				ConnectedComponent dc = new ConnectedComponent();

				switch (event.getAction()) {
				case MotionEvent.ACTION_DOWN:
					last.set(curr);
					start.set(last);
					mode = DRAG;
					Log.d("tag1", "actual location: " + event.getX() + " , "
							+ event.getY());
					Log.d("tag1", "addedmarkerlist: " + addedmarkerlist.size());

					Matrix inverse1 = new Matrix();
					getImageMatrix().invert(inverse1);
					float[] touchPoint1 = new float[] { event.getX(),
							event.getY() };
					Log.d("tag1", "inverse location: " + touchPoint1[0] + " , "
							+ touchPoint1[1]);

					if (editmode == true || markermode == true
							|| erasemode == true) {

						Matrix inverse = new Matrix();
						getImageMatrix().invert(inverse);
						float[] touchPoint = new float[] { event.getX(),
								event.getY() };
						inverse.mapPoints(touchPoint);
						rtop = touchPoint[1];
						rleft = touchPoint[0];

						dtop = touchPoint[1];
						dleft = touchPoint[0];

					}

					if (erasemode == true) {
						bmap = originalBmp;
						drawmat = new Mat(bmap.getHeight(), bmap.getWidth(),
								CvType.CV_8U);
						Matrix inverse = new Matrix();
						getImageMatrix().invert(inverse);
						float[] touchPoint = new float[] { event.getX(),
								event.getY() };
						inverse.mapPoints(touchPoint);
						for (int i = rectanglelist.size() - 1; i > -1; i--) {
							float itop = rectanglelist.get(i).top;
							float ileft = rectanglelist.get(i).left;
							float iright = rectanglelist.get(i).right;
							float ibottom = rectanglelist.get(i).bottom;

							if (itop > ibottom) {
								float temp;
								temp = itop;
								itop = ibottom;
								ibottom = temp;
							}
							if (ileft > iright) {
								float temp;
								temp = ileft;
								ileft = iright;
								iright = temp;
							}
							if (touchPoint[0] <= iright
									&& touchPoint[0] >= ileft) {
								if (touchPoint[1] <= ibottom
										&& touchPoint[1] >= itop) {
									rectanglelist.remove(i);
									drawRectangles();
								}
							}

						}

						for (int i = addedmarkerlist.size() - 1; i > -1; i--) {
							float itop = addedmarkerlist.get(i).top;
							float ileft = addedmarkerlist.get(i).left;
							float iright = addedmarkerlist.get(i).right;
							float ibottom = addedmarkerlist.get(i).bottom;

							if (itop > ibottom) {
								float temp;
								temp = itop;
								itop = ibottom;
								ibottom = temp;
							}
							if (ileft > iright) {
								float temp;
								temp = ileft;
								ileft = iright;
								iright = temp;
							}

							if (touchPoint[0] <= iright
									&& touchPoint[0] >= ileft) {
								if (touchPoint[1] <= ibottom
										&& touchPoint[1] >= itop) {
									addedmarkerlist.remove(i);
									drawRectangles();
								}
							}

						}

					}
					break;

				case MotionEvent.ACTION_MOVE:
					if (editmode == true || markermode == true
							|| erasemode == true) {
						mode = NONE;
						Matrix inverse = new Matrix();
						getImageMatrix().invert(inverse);
						float[] touchPoint = new float[] { event.getX(),
								event.getY() };
						inverse.mapPoints(touchPoint);
						rbottom = touchPoint[1];
						rright = touchPoint[0];

						// dc
						dc = new ConnectedComponent();
						dbottom = touchPoint[1];
						dright = touchPoint[0];
						dc.left = (int) dleft;
						dc.right = (int) dright;
						dc.top = (int) dtop;
						dc.bottom = (int) dbottom;
						drawcurrentrectangle();

					}

					if (mode == DRAG) {

						// get the new horizontal and vertical positions
						float deltaX = curr.x - last.x;
						float deltaY = curr.y - last.y;
						// if view width is larger than content size
						// (original
						// width and height) returns 0
						float fixTransX = getFixDragTrans(deltaX, viewWidth,
								origWidth * saveScale);
						float fixTransY = getFixDragTrans(deltaY, viewHeight,
								origHeight * saveScale);
						matrix.postTranslate(fixTransX, fixTransY);
						fixTrans();
						last.set(curr.x, curr.y);
						// Log.d("tag1", "edit or markers pending");
					}

					break;

				case MotionEvent.ACTION_UP:

					mode = NONE;

					int xDiff = (int) Math.abs(curr.x - start.x);
					int yDiff = (int) Math.abs(curr.y - start.y);
					if (xDiff < CLICK && yDiff < CLICK)
						performClick();
					// rtop > get top, rbottom < getBottom, rleft > getleft,
					// rright < getright

					// if (rtop > getTop() && rbottom < getBottom()
					// && rleft > getLeft() && rright < getRight()) {

					Drawable drawable = getDrawable();
					imagewidth = drawable.getIntrinsicWidth();
					imageheight = drawable.getIntrinsicHeight();

					float width = 0;
					float height = 0;
					float ivRight = 0;
					float ivBottom = 0;

					if (editmode == true) {

						Log.d("tag1", "width: " + width);
						Log.d("tag1", "height: " + height);

						Log.d("tag1", "rtop: " + rtop);
						Log.d("tag1", "rleft: " + rleft);
						Log.d("tag1", "rright: " + rright);
						Log.d("tag1", "rbottom: " + rbottom);

						width = imagewidth;
						height = imageheight;

						ivRight = getLeft() + width;
						ivBottom = getTop() + height;

						Log.d("tag1", "ivtop: " + getTop());
						Log.d("tag1", "ivleft: " + getLeft());
						Log.d("tag1", "ivright: " + ivRight);
						Log.d("tag1", "ivbottom: " + ivBottom);

						if (rtop > rbottom) {
							float temp;
							temp = rtop;
							rtop = rbottom;
							rbottom = temp;
						}
						if (rleft > rright) {
							float temp;
							temp = rleft;
							rleft = rright;
							rright = temp;
						}

						if (rtop > getTop() && rbottom < ivBottom
								&& rleft > getLeft() && rright < ivRight) {
							cc.left = (int) rleft;
							cc.right = (int) rright;
							cc.top = (int) rtop;
							cc.bottom = (int) rbottom;

							if (rtop > rbottom) {
								int temp;
								temp = cc.top;
								cc.top = cc.bottom;
								cc.bottom = temp;
							}
							if (rleft > rright) {
								int temp;
								temp = cc.left;
								cc.left = cc.right;
								cc.right = temp;
							}
							templist.add(cc);
							rectanglelist.add(cc);

							drawRectangles();
							Log.d("tag1", "drawn rectangle");

						} else {
							drawRectangles();
							Log.d("tag1", "no drawn rectangle");
							break;
						}

					}// here
					if (markermode == true) {

						Log.d("tag1", "width: " + width);
						Log.d("tag1", "height: " + height);

						Log.d("tag1", "rtop: " + rtop);
						Log.d("tag1", "rleft: " + rleft);
						Log.d("tag1", "rright: " + rright);
						Log.d("tag1", "rbottom: " + rbottom);

						width = imagewidth;
						height = imageheight;

						ivRight = getLeft() + width;
						ivBottom = getTop() + height;

						Log.d("tag1", "ivtop: " + getTop());
						Log.d("tag1", "ivleft: " + getLeft());
						Log.d("tag1", "ivright: " + ivRight);
						Log.d("tag1", "ivbottom: " + ivBottom);

						if (rtop > rbottom) {
							float temp;
							temp = rtop;
							rtop = rbottom;
							rbottom = temp;
						}
						if (rleft > rright) {
							float temp;
							temp = rleft;
							rleft = rright;
							rright = temp;
						}

						if (rtop > getTop() && rbottom < ivBottom
								&& rleft > getLeft() && rright < ivRight) {
							cc.left = (int) rleft;
							cc.right = (int) rright;
							cc.top = (int) rtop;
							cc.bottom = (int) rbottom;

							if (rtop > rbottom) {
								int temp;
								temp = cc.top;
								cc.top = cc.bottom;
								cc.bottom = temp;
							}
							if (rleft > rright) {
								int temp;
								temp = cc.left;
								cc.left = cc.right;
								cc.right = temp;
							}
							templist.add(cc);
							addedmarkerlist.add(cc);

							drawRectangles();
							Log.d("tag1", "drawn rectangle");
						} else {
							drawRectangles();
							Log.d("tag1", "no drawn rectangle");
							break;

						}
					}

					if (erasemode == true) {
						ArrayList rectdeletelist = new ArrayList();
						if (rtop > rbottom) {
							float temp;
							temp = rtop;
							rtop = rbottom;
							rbottom = temp;
						}
						if (rleft > rright) {
							float temp;
							temp = rleft;
							rleft = rright;
							rright = temp;
						}

						for (int i = rectanglelist.size() - 1; i > -1; i--) {
							float itop = rectanglelist.get(i).top;
							float ileft = rectanglelist.get(i).left;
							float iright = rectanglelist.get(i).right;
							float ibottom = rectanglelist.get(i).bottom;

							if (itop > ibottom) {
								float temp;
								temp = itop;
								itop = ibottom;
								ibottom = temp;
							}
							if (ileft > iright) {
								float temp;
								temp = ileft;
								ileft = iright;
								iright = temp;
							}

							if (iright <= rright && ileft >= rleft
									&& itop >= rtop && ibottom <= rbottom) {
								rectanglelist.remove(i);
								drawRectangles();

							} else {
								drawRectangles();
							}

						}

						for (int i = addedmarkerlist.size() - 1; i > -1; i--) {
							float itop = addedmarkerlist.get(i).top;
							float ileft = addedmarkerlist.get(i).left;
							float iright = addedmarkerlist.get(i).right;
							float ibottom = addedmarkerlist.get(i).bottom;

							if (itop > ibottom) {
								float temp;
								temp = itop;
								itop = ibottom;
								ibottom = temp;
							}
							if (ileft > iright) {
								float temp;
								temp = ileft;
								ileft = iright;
								iright = temp;
							}

							if (iright <= rright && ileft >= rleft
									&& itop >= rtop && ibottom <= rbottom) {
								addedmarkerlist.remove(i);
								drawRectangles();
							} else {
								drawRectangles();
							}

						}

					}

					break;

				case MotionEvent.ACTION_POINTER_UP:

					mode = NONE;

					break;
				}

				setImageMatrix(matrix);

				invalidate();
				return true; // indicate event was handled
			}

		});
		// here
		// Bitmap drawnbmp = Bitmap.createBitmap(drawmat.cols(), drawmat.rows(),
		// Bitmap.Config.RGB_565);
		// Utils.matToBitmap(drawmat, drawnbmp);
		// setImageBitmap(drawnbmp);
	}

	private void drawcurrentrectangle() {
		Utils.bitmapToMat(rectanglebmap, drawmat);
		if (markermode == true) {
			Core.rectangle(drawmat, new Point(dleft, dtop), new Point(dright,
					dbottom), new Scalar(255, 255, 0), 2);

			Bitmap drawnbmp = Bitmap.createBitmap(drawmat.cols(),
					drawmat.rows(), Bitmap.Config.RGB_565);
			Utils.matToBitmap(drawmat, drawnbmp);
			setImageBitmap(drawnbmp);
		} else if (editmode == true) {
			Core.rectangle(drawmat, new Point(dleft, dtop), new Point(dright,
					dbottom), new Scalar(255, 0, 0), 2);

			Bitmap drawnbmp = Bitmap.createBitmap(drawmat.cols(),
					drawmat.rows(), Bitmap.Config.RGB_565);
			Utils.matToBitmap(drawmat, drawnbmp);
			setImageBitmap(drawnbmp);
		} else if (erasemode == true) {
			Core.rectangle(drawmat, new Point(dleft, dtop), new Point(dright,
					dbottom), new Scalar(0, 0, 0), 2);

			Bitmap drawnbmp = Bitmap.createBitmap(drawmat.cols(),
					drawmat.rows(), Bitmap.Config.RGB_565);
			Utils.matToBitmap(drawmat, drawnbmp);
			setImageBitmap(drawnbmp);
		}
	}

	private void drawRectangles() {
		Utils.bitmapToMat(bmap, drawmat);
		for (int i = 0; i < rectanglelist.size(); i++) {
			Core.rectangle(drawmat, new Point(rectanglelist.get(i).left,
					rectanglelist.get(i).top), new Point(
					rectanglelist.get(i).right, rectanglelist.get(i).bottom),
					new Scalar(255, 0, 0), 2);
			Point org = new Point(rectanglelist.get(i).right,
					rectanglelist.get(i).top);
			Core.putText(drawmat, "" + i, org, 3, 1, new Scalar(0, 255, 0), 5);
		}
		for (int i = 0; i < addedmarkerlist.size(); i++) {
			Core.rectangle(
					drawmat,
					new Point(addedmarkerlist.get(i).left, addedmarkerlist
							.get(i).top),
					new Point(addedmarkerlist.get(i).right, addedmarkerlist
							.get(i).bottom), new Scalar(255, 255, 0), 2);
			Point org = new Point(addedmarkerlist.get(i).right,
					addedmarkerlist.get(i).top);
			Core.putText(drawmat, "" + i, org, 3, 1, new Scalar(0, 0, 255), 5);
		}
		Bitmap drawnbmp = Bitmap.createBitmap(drawmat.cols(), drawmat.rows(),
				Bitmap.Config.RGB_565);
		rectanglebmap = drawnbmp;
		Utils.matToBitmap(drawmat, drawnbmp);
		setImageBitmap(drawnbmp);

	};

	/*private void drawMarkers() {
		Utils.bitmapToMat(bmap, drawmat);
		for (int i = 0; i < addedmarkerlist.size(); i++) {
			Core.rectangle(
					drawmat,
					new Point(addedmarkerlist.get(i).left, addedmarkerlist
							.get(i).top),
					new Point(addedmarkerlist.get(i).right, addedmarkerlist
							.get(i).bottom), new Scalar(255, 255, 0), 2);
		}
		Bitmap drawnbmp = Bitmap.createBitmap(drawmat.cols(), drawmat.rows(),
				Bitmap.Config.RGB_565);
		Utils.matToBitmap(drawmat, drawnbmp);
		setImageBitmap(drawnbmp);

	};*/

	private class ScaleListener extends
			ScaleGestureDetector.SimpleOnScaleGestureListener {

		@Override
		public boolean onScaleBegin(ScaleGestureDetector detector) {
			mode = ZOOM;
			return true;
		}

		@Override
		public boolean onScale(ScaleGestureDetector detector) {
			if (editmode != true && markermode != true) {
				float mScaleFactor = detector.getScaleFactor();
				float origScale = saveScale;
				saveScale *= mScaleFactor;

				if (saveScale > maxScale) {
					// prevent zooming in too much
					saveScale = maxScale;
					mScaleFactor = maxScale / origScale;
				} else if (saveScale < minScale) {
					// prevent zooming out too much
					saveScale = minScale;
					mScaleFactor = minScale / origScale;
				}

				if (origWidth * saveScale <= viewWidth
						|| origHeight * saveScale <= viewHeight)
					matrix.postScale(mScaleFactor, mScaleFactor, viewWidth / 2,
							viewHeight / 2);
				else
					matrix.postScale(mScaleFactor, mScaleFactor,
							detector.getFocusX(), detector.getFocusY());

				fixTrans();

			}
			return true;
		}

	}

	void fixTrans() {
		matrix.getValues(m);
		float transX = m[Matrix.MTRANS_X];
		float transY = m[Matrix.MTRANS_Y];

		float fixTransX = getFixTrans(transX, viewWidth, origWidth * saveScale);
		float fixTransY = getFixTrans(transY, viewHeight, origHeight
				* saveScale);
		// if view height and width is not larger than original height and
		// weight, matrix would be created
		if (fixTransX != 0 || fixTransY != 0)
			matrix.postTranslate(fixTransX, fixTransY);
	}

	float getFixTrans(float trans, float viewSize, float contentSize) {
		float minTrans, maxTrans;

		if (contentSize <= viewSize) {
			minTrans = 0;
			maxTrans = viewSize - contentSize;
		} else {
			minTrans = viewSize - contentSize;
			maxTrans = 0;
		}

		if (trans < minTrans)
			return -trans + minTrans;
		if (trans > maxTrans)
			return -trans + maxTrans;
		return 0;
	}

	float getFixDragTrans(float delta, float viewSize, float contentSize) {
		if (contentSize <= viewSize) {
			return 0;
		}
		return delta;
	}

	@Override
	protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
		super.onMeasure(widthMeasureSpec, heightMeasureSpec);
		viewWidth = MeasureSpec.getSize(widthMeasureSpec);
		viewHeight = MeasureSpec.getSize(heightMeasureSpec);

		//
		// Rescales image on rotation
		//
		if (oldMeasuredHeight == viewWidth && oldMeasuredHeight == viewHeight
				|| viewWidth == 0 || viewHeight == 0)
			return;
		oldMeasuredHeight = viewHeight;
		oldMeasuredWidth = viewWidth;

		if (saveScale == 1) {
			// Fit to screen.
			float scale;

			Drawable drawable = getDrawable();
			if (drawable == null || drawable.getIntrinsicWidth() == 0
					|| drawable.getIntrinsicHeight() == 0)
				return;
			int bmWidth = drawable.getIntrinsicWidth();
			int bmHeight = drawable.getIntrinsicHeight();

			// Log.d("bmSize", "bmWidth: " + bmWidth + " bmHeight : " +
			// bmHeight);

			float scaleX = (float) viewWidth / (float) bmWidth;
			float scaleY = (float) viewHeight / (float) bmHeight;
			scale = Math.min(scaleX, scaleY);
			matrix.setScale(scale, scale);

			// Center the image
			float redundantYSpace = (float) viewHeight
					- (scale * (float) bmHeight);
			float redundantXSpace = (float) viewWidth
					- (scale * (float) bmWidth);
			redundantYSpace /= (float) 2;
			redundantXSpace /= (float) 2;

			matrix.postTranslate(redundantXSpace, redundantYSpace);

			origWidth = viewWidth - 2 * redundantXSpace;
			origHeight = viewHeight - 2 * redundantYSpace;
			setImageMatrix(matrix);

		}
		fixTrans();

	}

	public void confirmation() {
		// set all the lists to the edited lists
		componentlist = rectanglelist;
		markerlist = addedmarkerlist;
		// rectanglelist.clear();
		// addedmarkerlist.clear();
		// Collections.copy(FullscreenActivity.getComponentlist(),
		// componentlist);
		// Collections.copy(FullscreenActivity.getMarkerlist(), markerlist);
		FullscreenActivity.getComponentlist().clear();
		for (int i = 0; i < componentlist.size(); i++) {
			FullscreenActivity.getComponentlist().add(componentlist.get(i));
		}

		FullscreenActivity.getMarkerlist().clear();
		for (int i = 0; i < markerlist.size(); i++) {
			FullscreenActivity.getMarkerlist().add(markerlist.get(i));
		}

		// componentlist = rectanglelist;
		// markerlist = addedmarkerlist;
		Bitmap drawnbmp = Bitmap.createBitmap(drawmat.cols(), drawmat.rows(),
				Bitmap.Config.RGB_565);
		Utils.matToBitmap(drawmat, drawnbmp);

		// int width = drawnbmp.getWidth();
		// int height = drawnbmp.getHeight();

		// final Bitmap drawnbmpduplicate = Bitmap.createBitmap(width, height,
		// Bitmap.Config.ARGB_8888);

		// FullscreenActivity.activeBmp = drawnbmp;
		// FullscreenActivity.getActiveBmp().createBitmap(drawnbmp);
		// FullscreenActivity.getActiveBmp().create
		FullscreenActivity.activeBmp = drawnbmp.copy(Bitmap.Config.ARGB_8888,
				true);
	}

	@Override
	public void onWindowFocusChanged(boolean hasFocus) {
		super.onWindowFocusChanged(hasFocus);
		// Button button = (Button) findViewById(R.id.button2);
		// System.out.println(button.getLeft());
		// System.out.println(button.getRight());
		Log.d("tag1", "Left: " + getLeft());
		Log.d("tag1", "Right: " + getRight());
		Log.d("tag1", "Top: " + getTop());
		Log.d("tag1", "Bottom: " + getBottom());
	}

}
